package day0401;

import java.util.Scanner;


public class Dfs26 {
    /**
     * 26.机器人走迷宫
     * 机器人走迷宫 深度优先搜索
     * <p>
     * 1.房间由XY的方格组成，例如下图为24的大小。每一个方格以坐标(x，y)描述
     * <p>
     * 2.机器人固定从方格(0，0)出发，只能向东或者向北前进。出口固定为房间的最东北角，如下图的方格(5，3)。用例保证机器人可以从入口走到出口。
     * <p>
     * 3.房间有些方格是墙壁，如(4，1)，机器人不能经过那儿。
     * <p>
     * 4.有些地方是一旦到达就无法走到出口的，如标记为B的方格，称之为陷阱方格。
     * <p>
     * 5.有些地方是机器人无法到达的的，如标记为A的方格，称之为不可达方格，不可达方格不包括墙壁所在的位置.
     * <p>
     * 6.如下示例图中，陷阱方格有2个，不可达方格有3个。
     * <p>
     * 7.请为该机器人实现路径规划功能: 给定房间大小、墙壁位置，请计算出陷阱方格与不可达方格分别有多少个
     * <p>
     * 输入描述
     * <p>
     * 第一行为房间的X和Y (0 < X，Y = 1000)
     * 第二行为房间中墙壁的个数N (0 = N< X*Y)
     * 同一行中如果有多个数据以一个空格隔开，用例保证所有的输入数据均合法。 (结尾不带回车换行)
     * <p>
     * 输出描述
     * <p>
     * 陷阱方格与不可达方格数量，两个信息在一行中输出，以一个空格隔开。(结尾不带回车换行)
     * <p>
     * 输入：
     * 6 4
     * 5
     * 0 2
     * 1 2
     * 2 2
     * 4 1
     * 5 1
     */
    // 方向(先上后右)
    private static final int px[] = {-1, 0};
    private static final int py[] = {0, 1};

    // 陷阱个数
    private static int xj = 0;
    // 不可达个数
    private static int bkd = 0;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] nm = sc.nextLine().split(" ");
        int n = Integer.parseInt(nm[0]);
        int m = Integer.parseInt(nm[1]);
        // 迷宫
        int[][] graph = new int[m][n];
        // 走过的
        int[][] used = new int[m][n];
        // 初始值换成2
        graph[m - 1][0] = 2;
        used[m - 1][0] = 2;

        int k = Integer.parseInt(sc.nextLine());
        // 标记墙的坐标为1
        for (int i = 0; i < k; i++) {
            String[] wall = sc.nextLine().split(" ");
            int x = Integer.parseInt(wall[0]);
            int y = Integer.parseInt(wall[1]);
            graph[m - y - 1][x] = 1;
            used[m - y - 1][x] = 1;
        }
        dfs(graph, used, 3, 0);
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (used[i][j] == 0) {
                    bkd++;
                }
            }
        }
        System.out.println(xj + " " + bkd);

    }

    private static boolean dfs(int[][] graph, int[][] used, int x, int y) {
        // 是否到出口的标志
        boolean flag = false;
        int m = graph.length;
        int n = graph[0].length;
        // 出口坐标
        int goal_x = 0;
        int goal_y = n - 1;
        if (x == goal_x && y == goal_y) {
            return true;
        }
        for (int i = 0; i < 2; i++) {
            int new_x = x + px[i];
            int new_y = y + py[i];
            if (new_x >= 0 && new_x < m && new_y >= 0 && new_y < n && graph[new_x][new_y] == 0) {
                graph[new_x][new_y] = 2; // 设置该格子走过了,在原位置上改
                used[new_x][new_y] = 2; // 设置该格子走过了
                if (dfs(graph, used, new_x, new_y)) {// 递归
                    flag = true;
                }
                graph[new_x][new_y] = 0; // 状态回溯,将格子设为未走过
            }
        }
        if (!flag) {
            xj++;// 统计陷阱数量
        }
        return flag;
    }
}
